﻿using System.Collections;
using System.Security.Cryptography.X509Certificates;

namespace C_初级教程
{

    /// <summary>
    /// 数组
    /// </summary>
    public class 数组
    {
        // 1、一维数组
        //数组的初始化的四种方式
        public static void test()
        {
            //数组的长度是固定的。
            //数组是引用类型，所以需要new关键字来初始化数组。
            //初始化数组
            //声明一个数组不会在内存中初始化数组。

            int[] arr;  // 没有初始化数组，没有分配没存，仅仅是有声明了指针

            arr = new int[5];//new后在堆上给数组分配了内存，规定其长度

            //通过下表给数据元素赋值

            arr[0] = 1;
            arr[1] = 2;
            arr[2] = 10;
            arr[3] = 20;
            arr[4] = 19;
            // arr[5] =8;   报错，索引超出范围

            //第二种初始化数组的方式
            double[] arr2 = new double[5] { 3.1, 3.5, 2.3, 2.5, 2.6 };

            //第三种初始化方式
            float[] arr3 = new float[] { }; //在堆上为数组分配了内存，只不过元素个数为0

            float[] arr4 = new float[] { 3.2f, 3.65f };//不给定长度

            //第四种初始化方式
            float[] arr5 = { 3.2f, 3.9f };


            //对数组进行冒泡排序(在C#中不用自己写)
            int[] arr6 = { 1, 23, 14, 5, 12, 11 };
            for (int i = 0; i < arr6.Length; i++)
            {
                for (int j = i; j < arr6.Length; j++)
                {
                    if (arr6[j] > arr6[j + 1])
                    {
                        int aa;
                        aa = arr6[j];
                        arr6[j] = arr6[j + 1];
                        arr6[j] = aa;
                    }
                }
            }
            //冒泡排序在C#中不用自己写
            Array.Sort(arr6);


            //2、多维数组
            int[,] arr9 = new int[,] {
                        { 12,1,2},
                        { 1,2,3}
                    };

            //长度 （每一维数组长度之和  2*3）
            arr9.Length;
            //维数
            arr9.Rank;

            //访问元素
            int a = arr9[0, 2];

            //遍历
            //(有几维就要嵌套多少层)
            for (int i = 0; i < 2; i++)
            {
                for (int j = 0; j < 3; j++)
                {

                }
            }

            //3、数组作为参数传递
            //数组为引用类型，所以数组作为参数传递给函数时，是按照引用传递的，所以函数中对数组的修改会影响函数外数组的实际数据
            // 引用传递，本质上传的是传的地址，引用类型参数传递的也是地址（引用传递本质上是按照引用类型传递，传递的是地址）
            // 引用类型做参数，就是按引用传递
        }
        //4、参数数组
        //当声明一个方法时，您不能确定要传递给函数的参数数目，参数数组解决了这个问题。
        public static int addElement(params int[] arr)
        {
            int sum = 0;

            foreach (int a in arr)
            {
                sum += a;
            }
            return sum;
        }

        public static int  aa()
        {
            int sum = addElement(100,2,233,33);//此处参数可以为任意数量
            return sum;
        }

}
    }


    /// <summary>
    /// 集合
    /// </summary>
    public class 集合
    {
        //ArrayList动态数组(底层本质上还是封装了一个数组，本质是数组)


        public static void testc()
        {
            //创建动态数组对象，分配内存空间
            ArrayList arr = new ArrayList();

            //一个个添加
            arr.Add(11);
            arr.Add(123);
            arr.Add(90);
            //批量添加（直接添加一个数组）
            arr.AddRange(new int[] { 12, 12, 22, 44 });


            //访问元素
            int temp = (int)arr[0];

            //遍历
            //遍历过程中不能对动态数组元素进行增、删、改
            foreach (int a in arr)
            { 
                
            }

            //移除元素
                //①根据元素值
                    arr.Remove(123);
                //②根据元素下标
                    arr.RemoveAt(0);

            arr.Capacity;  //此属性，返回动态数组的容量 (容量是实际元素数量的两倍，而且不断扩容)
            arr.Count;     // 返回动态数组当前元素个数      --注意： 容量和当前元素个数是不同的概念，容量一般大于实际元素数量，且随着实际数量增加，动态数组会自动扩容

        }
        

        

    }
}
